﻿using System;
using System.Diagnostics;
using System.IO;
using Google.ProtocolBuffers;
using Google.ProtocolBuffers.Descriptors;
using Google.ProtocolBuffers.FieldAccess;

namespace com.gexin.rp.sdk.dto
{
	// Token: 0x02000011 RID: 17
	[DebuggerNonUserCode]
	public sealed class SingleBatchItem : GeneratedMessage<SingleBatchItem, SingleBatchItem.Builder>
	{
		// Token: 0x06000179 RID: 377 RVA: 0x00004752 File Offset: 0x00002952
		private SingleBatchItem()
		{
		}

		// Token: 0x1700009D RID: 157
		// (get) Token: 0x0600017A RID: 378 RVA: 0x0000476C File Offset: 0x0000296C
		public static SingleBatchItem DefaultInstance
		{
			get
			{
				return SingleBatchItem.defaultInstance;
			}
		}

		// Token: 0x1700009E RID: 158
		// (get) Token: 0x0600017B RID: 379 RVA: 0x00004773 File Offset: 0x00002973
		public override SingleBatchItem DefaultInstanceForType
		{
			get
			{
				return SingleBatchItem.DefaultInstance;
			}
		}

		// Token: 0x1700009F RID: 159
		// (get) Token: 0x0600017C RID: 380 RVA: 0x00002579 File Offset: 0x00000779
		protected override SingleBatchItem ThisMessage
		{
			get
			{
				return this;
			}
		}

		// Token: 0x170000A0 RID: 160
		// (get) Token: 0x0600017D RID: 381 RVA: 0x0000477A File Offset: 0x0000297A
		public static MessageDescriptor Descriptor
		{
			get
			{
				return GtReq.internal__static_com_gexin_rp_sdk_dto_SingleBatchItem__Descriptor;
			}
		}

		// Token: 0x170000A1 RID: 161
		// (get) Token: 0x0600017E RID: 382 RVA: 0x00004781 File Offset: 0x00002981
		protected override FieldAccessorTable<SingleBatchItem, SingleBatchItem.Builder> InternalFieldAccessors
		{
			get
			{
				return GtReq.internal__static_com_gexin_rp_sdk_dto_SingleBatchItem__FieldAccessorTable;
			}
		}

		// Token: 0x170000A2 RID: 162
		// (get) Token: 0x0600017F RID: 383 RVA: 0x00004788 File Offset: 0x00002988
		public bool HasSeqId
		{
			get
			{
				return this.hasSeqId;
			}
		}

		// Token: 0x170000A3 RID: 163
		// (get) Token: 0x06000180 RID: 384 RVA: 0x00004790 File Offset: 0x00002990
		public int SeqId
		{
			get
			{
				return this.seqId_;
			}
		}

		// Token: 0x170000A4 RID: 164
		// (get) Token: 0x06000181 RID: 385 RVA: 0x00004798 File Offset: 0x00002998
		public bool HasData
		{
			get
			{
				return this.hasData;
			}
		}

		// Token: 0x170000A5 RID: 165
		// (get) Token: 0x06000182 RID: 386 RVA: 0x000047A0 File Offset: 0x000029A0
		public string Data
		{
			get
			{
				return this.data_;
			}
		}

		// Token: 0x170000A6 RID: 166
		// (get) Token: 0x06000183 RID: 387 RVA: 0x000047A8 File Offset: 0x000029A8
		public override bool IsInitialized
		{
			get
			{
				return this.hasSeqId && this.hasData;
			}
		}

		// Token: 0x06000184 RID: 388 RVA: 0x000047C0 File Offset: 0x000029C0
		public override void WriteTo(ICodedOutputStream output)
		{
			this.CalcSerializedSize();
			string[] singleBatchItemFieldNames = SingleBatchItem._singleBatchItemFieldNames;
			if (this.hasSeqId)
			{
				output.WriteInt32(1, singleBatchItemFieldNames[1], this.SeqId);
			}
			if (this.hasData)
			{
				output.WriteString(2, singleBatchItemFieldNames[0], this.Data);
			}
			this.UnknownFields.WriteTo(output);
		}

		// Token: 0x170000A7 RID: 167
		// (get) Token: 0x06000185 RID: 389 RVA: 0x00004818 File Offset: 0x00002A18
		public override int SerializedSize
		{
			get
			{
				int num = this.memoizedSerializedSize;
				if (num != -1)
				{
					return num;
				}
				return this.CalcSerializedSize();
			}
		}

		// Token: 0x06000186 RID: 390 RVA: 0x00004838 File Offset: 0x00002A38
		private int CalcSerializedSize()
		{
			int num = this.memoizedSerializedSize;
			if (num != -1)
			{
				return num;
			}
			num = 0;
			if (this.hasSeqId)
			{
				num += CodedOutputStream.ComputeInt32Size(1, this.SeqId);
			}
			if (this.hasData)
			{
				num += CodedOutputStream.ComputeStringSize(2, this.Data);
			}
			num += this.UnknownFields.SerializedSize;
			this.memoizedSerializedSize = num;
			return num;
		}

		// Token: 0x06000187 RID: 391 RVA: 0x00004898 File Offset: 0x00002A98
		public static SingleBatchItem ParseFrom(ByteString data)
		{
			return SingleBatchItem.CreateBuilder().MergeFrom(data).BuildParsed();
		}

		// Token: 0x06000188 RID: 392 RVA: 0x000048AA File Offset: 0x00002AAA
		public static SingleBatchItem ParseFrom(ByteString data, ExtensionRegistry extensionRegistry)
		{
			return SingleBatchItem.CreateBuilder().MergeFrom(data, extensionRegistry).BuildParsed();
		}

		// Token: 0x06000189 RID: 393 RVA: 0x000048BD File Offset: 0x00002ABD
		public static SingleBatchItem ParseFrom(byte[] data)
		{
			return SingleBatchItem.CreateBuilder().MergeFrom(data).BuildParsed();
		}

		// Token: 0x0600018A RID: 394 RVA: 0x000048CF File Offset: 0x00002ACF
		public static SingleBatchItem ParseFrom(byte[] data, ExtensionRegistry extensionRegistry)
		{
			return SingleBatchItem.CreateBuilder().MergeFrom(data, extensionRegistry).BuildParsed();
		}

		// Token: 0x0600018B RID: 395 RVA: 0x000048E2 File Offset: 0x00002AE2
		public static SingleBatchItem ParseFrom(Stream input)
		{
			return SingleBatchItem.CreateBuilder().MergeFrom(input).BuildParsed();
		}

		// Token: 0x0600018C RID: 396 RVA: 0x000048F4 File Offset: 0x00002AF4
		public static SingleBatchItem ParseFrom(Stream input, ExtensionRegistry extensionRegistry)
		{
			return SingleBatchItem.CreateBuilder().MergeFrom(input, extensionRegistry).BuildParsed();
		}

		// Token: 0x0600018D RID: 397 RVA: 0x00004907 File Offset: 0x00002B07
		public static SingleBatchItem ParseDelimitedFrom(Stream input)
		{
			return SingleBatchItem.CreateBuilder().MergeDelimitedFrom(input).BuildParsed();
		}

		// Token: 0x0600018E RID: 398 RVA: 0x00004919 File Offset: 0x00002B19
		public static SingleBatchItem ParseDelimitedFrom(Stream input, ExtensionRegistry extensionRegistry)
		{
			return SingleBatchItem.CreateBuilder().MergeDelimitedFrom(input, extensionRegistry).BuildParsed();
		}

		// Token: 0x0600018F RID: 399 RVA: 0x0000492C File Offset: 0x00002B2C
		public static SingleBatchItem ParseFrom(ICodedInputStream input)
		{
			return SingleBatchItem.CreateBuilder().MergeFrom(input).BuildParsed();
		}

		// Token: 0x06000190 RID: 400 RVA: 0x0000493E File Offset: 0x00002B3E
		public static SingleBatchItem ParseFrom(ICodedInputStream input, ExtensionRegistry extensionRegistry)
		{
			return SingleBatchItem.CreateBuilder().MergeFrom(input, extensionRegistry).BuildParsed();
		}

		// Token: 0x06000191 RID: 401 RVA: 0x00002579 File Offset: 0x00000779
		private SingleBatchItem MakeReadOnly()
		{
			return this;
		}

		// Token: 0x06000192 RID: 402 RVA: 0x00004951 File Offset: 0x00002B51
		public static SingleBatchItem.Builder CreateBuilder()
		{
			return new SingleBatchItem.Builder();
		}

		// Token: 0x06000193 RID: 403 RVA: 0x00004958 File Offset: 0x00002B58
		public override SingleBatchItem.Builder ToBuilder()
		{
			return SingleBatchItem.CreateBuilder(this);
		}

		// Token: 0x06000194 RID: 404 RVA: 0x00004951 File Offset: 0x00002B51
		public override SingleBatchItem.Builder CreateBuilderForType()
		{
			return new SingleBatchItem.Builder();
		}

		// Token: 0x06000195 RID: 405 RVA: 0x00004960 File Offset: 0x00002B60
		public static SingleBatchItem.Builder CreateBuilder(SingleBatchItem prototype)
		{
			return new SingleBatchItem.Builder(prototype);
		}

		// Token: 0x06000196 RID: 406 RVA: 0x00004968 File Offset: 0x00002B68
		static SingleBatchItem()
		{
			FileDescriptor descriptor = GtReq.Descriptor;
		}

		// Token: 0x040000ED RID: 237
		private static readonly SingleBatchItem defaultInstance = new SingleBatchItem().MakeReadOnly();

		// Token: 0x040000EE RID: 238
		private static readonly string[] _singleBatchItemFieldNames = new string[]
		{
			"data",
			"seqId"
		};

		// Token: 0x040000EF RID: 239
		private static readonly uint[] _singleBatchItemFieldTags = new uint[]
		{
			18u,
			8u
		};

		// Token: 0x040000F0 RID: 240
		public const int SeqIdFieldNumber = 1;

		// Token: 0x040000F1 RID: 241
		private bool hasSeqId;

		// Token: 0x040000F2 RID: 242
		private int seqId_;

		// Token: 0x040000F3 RID: 243
		public const int DataFieldNumber = 2;

		// Token: 0x040000F4 RID: 244
		private bool hasData;

		// Token: 0x040000F5 RID: 245
		private string data_ = "";

		// Token: 0x040000F6 RID: 246
		private int memoizedSerializedSize = -1;

		// Token: 0x0200005D RID: 93
		[DebuggerNonUserCode]
		public sealed class Builder : GeneratedBuilder<SingleBatchItem, SingleBatchItem.Builder>
		{
			// Token: 0x170002EC RID: 748
			// (get) Token: 0x06000728 RID: 1832 RVA: 0x00002579 File Offset: 0x00000779
			protected override SingleBatchItem.Builder ThisBuilder
			{
				get
				{
					return this;
				}
			}

			// Token: 0x06000729 RID: 1833 RVA: 0x0001113D File Offset: 0x0000F33D
			public Builder()
			{
				this.result = SingleBatchItem.DefaultInstance;
				this.resultIsReadOnly = true;
			}

			// Token: 0x0600072A RID: 1834 RVA: 0x00011157 File Offset: 0x0000F357
			internal Builder(SingleBatchItem cloneFrom)
			{
				this.result = cloneFrom;
				this.resultIsReadOnly = true;
			}

			// Token: 0x0600072B RID: 1835 RVA: 0x00011170 File Offset: 0x0000F370
			private SingleBatchItem PrepareBuilder()
			{
				if (this.resultIsReadOnly)
				{
					SingleBatchItem other = this.result;
					this.result = new SingleBatchItem();
					this.resultIsReadOnly = false;
					this.MergeFrom(other);
				}
				return this.result;
			}

			// Token: 0x170002ED RID: 749
			// (get) Token: 0x0600072C RID: 1836 RVA: 0x000111AC File Offset: 0x0000F3AC
			public override bool IsInitialized
			{
				get
				{
					return this.result.IsInitialized;
				}
			}

			// Token: 0x170002EE RID: 750
			// (get) Token: 0x0600072D RID: 1837 RVA: 0x000111B9 File Offset: 0x0000F3B9
			protected override SingleBatchItem MessageBeingBuilt
			{
				get
				{
					return this.PrepareBuilder();
				}
			}

			// Token: 0x0600072E RID: 1838 RVA: 0x000111C1 File Offset: 0x0000F3C1
			public override SingleBatchItem.Builder Clear()
			{
				this.result = SingleBatchItem.DefaultInstance;
				this.resultIsReadOnly = true;
				return this;
			}

			// Token: 0x0600072F RID: 1839 RVA: 0x000111D6 File Offset: 0x0000F3D6
			public override SingleBatchItem.Builder Clone()
			{
				if (this.resultIsReadOnly)
				{
					return new SingleBatchItem.Builder(this.result);
				}
				return new SingleBatchItem.Builder().MergeFrom(this.result);
			}

			// Token: 0x170002EF RID: 751
			// (get) Token: 0x06000730 RID: 1840 RVA: 0x000111FC File Offset: 0x0000F3FC
			public override MessageDescriptor DescriptorForType
			{
				get
				{
					return SingleBatchItem.Descriptor;
				}
			}

			// Token: 0x170002F0 RID: 752
			// (get) Token: 0x06000731 RID: 1841 RVA: 0x00004773 File Offset: 0x00002973
			public override SingleBatchItem DefaultInstanceForType
			{
				get
				{
					return SingleBatchItem.DefaultInstance;
				}
			}

			// Token: 0x06000732 RID: 1842 RVA: 0x00011203 File Offset: 0x0000F403
			public override SingleBatchItem BuildPartial()
			{
				if (this.resultIsReadOnly)
				{
					return this.result;
				}
				this.resultIsReadOnly = true;
				return this.result.MakeReadOnly();
			}

			// Token: 0x06000733 RID: 1843 RVA: 0x00011226 File Offset: 0x0000F426
			public override SingleBatchItem.Builder MergeFrom(IMessage other)
			{
				if (other is SingleBatchItem)
				{
					return this.MergeFrom((SingleBatchItem)other);
				}
				base.MergeFrom(other);
				return this;
			}

			// Token: 0x06000734 RID: 1844 RVA: 0x00011248 File Offset: 0x0000F448
			public override SingleBatchItem.Builder MergeFrom(SingleBatchItem other)
			{
				if (other == SingleBatchItem.DefaultInstance)
				{
					return this;
				}
				this.PrepareBuilder();
				if (other.HasSeqId)
				{
					this.SeqId = other.SeqId;
				}
				if (other.HasData)
				{
					this.Data = other.Data;
				}
				this.MergeUnknownFields(other.UnknownFields);
				return this;
			}

			// Token: 0x06000735 RID: 1845 RVA: 0x0001129C File Offset: 0x0000F49C
			public override SingleBatchItem.Builder MergeFrom(ICodedInputStream input)
			{
				return this.MergeFrom(input, ExtensionRegistry.Empty);
			}

			// Token: 0x06000736 RID: 1846 RVA: 0x000112AC File Offset: 0x0000F4AC
			public override SingleBatchItem.Builder MergeFrom(ICodedInputStream input, ExtensionRegistry extensionRegistry)
			{
				this.PrepareBuilder();
				UnknownFieldSet.Builder builder = null;
				uint num;
				string text;
				while (input.ReadTag(out num, out text))
				{
					if (num == 0u && text != null)
					{
						int num2 = Array.BinarySearch<string>(SingleBatchItem._singleBatchItemFieldNames, text, StringComparer.Ordinal);
						if (num2 < 0)
						{
							if (builder == null)
							{
								builder = UnknownFieldSet.CreateBuilder(this.UnknownFields);
							}
							this.ParseUnknownField(input, builder, extensionRegistry, num, text);
							continue;
						}
						num = SingleBatchItem._singleBatchItemFieldTags[num2];
					}
					if (num == 0u)
					{
						throw InvalidProtocolBufferException.InvalidTag();
					}
					if (num != 8u)
					{
						if (num != 18u)
						{
							if (WireFormat.IsEndGroupTag(num))
							{
								if (builder != null)
								{
									this.UnknownFields = builder.Build();
								}
								return this;
							}
							if (builder == null)
							{
								builder = UnknownFieldSet.CreateBuilder(this.UnknownFields);
							}
							this.ParseUnknownField(input, builder, extensionRegistry, num, text);
						}
						else
						{
							this.result.hasData = input.ReadString(ref this.result.data_);
						}
					}
					else
					{
						this.result.hasSeqId = input.ReadInt32(ref this.result.seqId_);
					}
				}
				if (builder != null)
				{
					this.UnknownFields = builder.Build();
				}
				return this;
			}

			// Token: 0x170002F1 RID: 753
			// (get) Token: 0x06000737 RID: 1847 RVA: 0x000113AF File Offset: 0x0000F5AF
			public bool HasSeqId
			{
				get
				{
					return this.result.hasSeqId;
				}
			}

			// Token: 0x170002F2 RID: 754
			// (get) Token: 0x06000738 RID: 1848 RVA: 0x000113BC File Offset: 0x0000F5BC
			// (set) Token: 0x06000739 RID: 1849 RVA: 0x000113C9 File Offset: 0x0000F5C9
			public int SeqId
			{
				get
				{
					return this.result.SeqId;
				}
				set
				{
					this.SetSeqId(value);
				}
			}

			// Token: 0x0600073A RID: 1850 RVA: 0x000113D3 File Offset: 0x0000F5D3
			public SingleBatchItem.Builder SetSeqId(int value)
			{
				this.PrepareBuilder();
				this.result.hasSeqId = true;
				this.result.seqId_ = value;
				return this;
			}

			// Token: 0x0600073B RID: 1851 RVA: 0x000113F5 File Offset: 0x0000F5F5
			public SingleBatchItem.Builder ClearSeqId()
			{
				this.PrepareBuilder();
				this.result.hasSeqId = false;
				this.result.seqId_ = 0;
				return this;
			}

			// Token: 0x170002F3 RID: 755
			// (get) Token: 0x0600073C RID: 1852 RVA: 0x00011417 File Offset: 0x0000F617
			public bool HasData
			{
				get
				{
					return this.result.hasData;
				}
			}

			// Token: 0x170002F4 RID: 756
			// (get) Token: 0x0600073D RID: 1853 RVA: 0x00011424 File Offset: 0x0000F624
			// (set) Token: 0x0600073E RID: 1854 RVA: 0x00011431 File Offset: 0x0000F631
			public string Data
			{
				get
				{
					return this.result.Data;
				}
				set
				{
					this.SetData(value);
				}
			}

			// Token: 0x0600073F RID: 1855 RVA: 0x0001143B File Offset: 0x0000F63B
			public SingleBatchItem.Builder SetData(string value)
			{
				ThrowHelper.ThrowIfNull(value, "value");
				this.PrepareBuilder();
				this.result.hasData = true;
				this.result.data_ = value;
				return this;
			}

			// Token: 0x06000740 RID: 1856 RVA: 0x00011468 File Offset: 0x0000F668
			public SingleBatchItem.Builder ClearData()
			{
				this.PrepareBuilder();
				this.result.hasData = false;
				this.result.data_ = "";
				return this;
			}

			// Token: 0x04000351 RID: 849
			private bool resultIsReadOnly;

			// Token: 0x04000352 RID: 850
			private SingleBatchItem result;
		}
	}
}
